Perhaps the single most important feature of the modem day Graphical User Interface (GUI) debugger is its ability to display runtime object data to a developer in a very simple and meaningful way. As such, it is important that when the debugger displays this information, it displays it in such a way that the values which developers are most interested in are displayed prominently. Unfortunately, it is not possible for any debugger to analyze arbitrary objects to determine what the developer is actually interested in knowing. This can lead to significant issues in debugging large complicated objects. In particular, debugging objects having data that cannot be represented in a hierarchical manner, for example the nature of is instead relational or perhaps even visual, is quite difficult.
Consider, in one example, a bitmap object that contains information about its size, bits per pixel, and so forth. This information is usually easily accessible through a hierarchical view (e.g., standard view of typed data as a tree structure); however, it is generally not possible for the developer to get an understanding of what the image looks like by merely observing the binary data. However, a bitmap likely has other representations (e.g., image of an eagle rather than ones and zeros display) that would likely provide the developer much more information then with the traditional representation of the bitmap. As can be appreciated, visualization problems can be found with other types of data formats in addition to bitmaps (e.g., string representations of data, data sets, relational databases, XML, and so forth).
Continuing with the bitmap example above—such as from a bitmap that is part of a tree structure view, when developers expand the bitmap they are presented with a confusing binary representation of the data. At best, the developer or user may be able to determine the dimensions of the bitmap which they are viewing, but it's very unlikely that they will be able to determine what the bitmap actually looks like. A second and perhaps even more compelling example is the view given to structured database language while debugging. In particular, it is virtually impossible for the developer to actually understand what information is stored in the respective tables of a data set.